home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / bstring / RCS / bcopy.c,v < prev    next >
Text File  |  1992-05-14  |  9KB  |  437 lines
  1. head     1.9;
  2. branch   ;
  3. access   ;
  4. symbols  sprited:1.7.1;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.9
  10. date     92.05.14.18.57.09;  author kupfer;  state Exp;
  11. branches ;
  12. next     1.8;
  13.  
  14. 1.8
  15. date     92.03.27.13.32.23;  author rab;  state Exp;
  16. branches ;
  17. next     1.7;
  18.  
  19. 1.7
  20. date     91.03.24.19.03.11;  author kupfer;  state Exp;
  21. branches 1.7.1.1;
  22. next     1.6;
  23.  
  24. 1.6
  25. date     90.09.11.14.13.21;  author kupfer;  state Exp;
  26. branches ;
  27. next     1.5;
  28.  
  29. 1.5
  30. date     90.09.07.14.20.30;  author jhh;  state Exp;
  31. branches ;
  32. next     1.4;
  33.  
  34. 1.4
  35. date     88.07.25.13.16.02;  author ouster;  state Exp;
  36. branches ;
  37. next     1.3;
  38.  
  39. 1.3
  40. date     88.07.19.13.26.46;  author mendel;  state Exp;
  41. branches ;
  42. next     1.2;
  43.  
  44. 1.2
  45. date     88.04.25.21.32.57;  author ouster;  state Exp;
  46. branches ;
  47. next     1.1;
  48.  
  49. 1.1
  50. date     88.04.25.17.21.58;  author ouster;  state Exp;
  51. branches ;
  52. next     ;
  53.  
  54. 1.7.1.1
  55. date     91.12.02.21.28.12;  author kupfer;  state Exp;
  56. branches ;
  57. next     ;
  58.  
  59.  
  60. desc
  61. @@
  62.  
  63.  
  64. 1.9
  65. log
  66. @Remove the debug check for bogus accesses to user addresses.  Use the
  67. ANSI signature (void pointers, etc).
  68. @
  69. text
  70. @/* 
  71.  * bcopy.c --
  72.  *
  73.  *    Source code for the "bcopy" library routine.
  74.  *
  75.  * Copyright 1988 Regents of the University of California
  76.  * Permission to use, copy, modify, and distribute this
  77.  * software and its documentation for any purpose and without
  78.  * fee is hereby granted, provided that the above copyright
  79.  * notice appear in all copies.  The University of California
  80.  * makes no representations about the suitability of this
  81.  * software for any purpose.  It is provided "as is" without
  82.  * express or implied warranty.
  83.  */
  84.  
  85. #ifndef lint
  86. static char rcsid[] = "$Header: /sprite/src/lib/c/bstring/RCS/bcopy.c,v 1.8 92/03/27 13:32:23 rab Exp Locker: kupfer $ SPRITE (Berkeley)";
  87. #endif not lint
  88.  
  89. #include <bstring.h>
  90. #include <machparam.h>
  91.  
  92. /*
  93.  * The following mask is used to detect proper alignment of addresses
  94.  * for doing word operations instead of byte operations.  It is
  95.  * machine-dependent.  If none of the following bits are set in an
  96.  * address, then word-based operations may be used. This value is imported
  97.  * from machparam.h
  98.  */
  99.  
  100. /*
  101.  * Just because we can do loads from half-word addresses on a sun3 doesn't
  102.  * mean we want to.  Make sure the load address is word-aligned and you'll
  103.  * bcopy twice as fast when the dest is greater than the source.
  104.  */
  105. #ifdef sun3
  106. #define WORDMASK 0x3
  107. #else
  108. #define WORDMASK WORD_ALIGN_MASK
  109. #endif
  110.  
  111. /*
  112.  *----------------------------------------------------------------------
  113.  *
  114.  * bcopy --
  115.  *
  116.  *    Copy numBytes from *sourcePtr to *destPtr.  This routine is
  117.  *    optimized to do transfers when sourcePtr and destPtr are both
  118.  *    integer-aligned and point to large areas.
  119.  *
  120.  * Results:
  121.  *    There is no return value.  The memory at *destPtr is modified.
  122.  *
  123.  * Side effects:
  124.  *    None.
  125.  *
  126.  *----------------------------------------------------------------------
  127.  */
  128.  
  129. void
  130. bcopy(sourceVoidPtr, destVoidPtr, numBytes)
  131.     _CONST _VoidPtr sourceVoidPtr; /* Where to copy from */
  132.     _VoidPtr destVoidPtr;    /* Where to copy to */
  133.     register int numBytes;    /* The number of bytes to copy */
  134. {
  135.     register _CONST int *sPtr = (int *) sourceVoidPtr;
  136.     register int *dPtr = (int *) destVoidPtr;
  137.     _CONST char *sourcePtr = sourceVoidPtr;
  138.     char *destPtr = destVoidPtr;
  139.  
  140.     /*
  141.      * If the destination is below the source then it is safe to copy
  142.      * in the forward direction.  Otherwise, we must start at the top
  143.      * and work down, again optimizing for large transfers.
  144.      */
  145.  
  146.     if (dPtr < sPtr) {
  147.     /*
  148.      * If both the source and the destination point to aligned
  149.      * addresses then copy as much as we can in large transfers.  Once
  150.      * we have less than a whole int to copy then it must be done by
  151.      * byte transfers.  Furthermore, use an expanded loop to avoid
  152.      * the overhead of continually testing loop variables.
  153.      */
  154.  
  155.     if (!((((int) sPtr) | (int) dPtr) & WORDMASK)) {
  156.         while (numBytes >= 16*sizeof(int)) {
  157.         dPtr[0] = sPtr[0];
  158.         dPtr[1] = sPtr[1];
  159.         dPtr[2] = sPtr[2];
  160.         dPtr[3] = sPtr[3];
  161.         dPtr[4] = sPtr[4];
  162.         dPtr[5] = sPtr[5];
  163.         dPtr[6] = sPtr[6];
  164.         dPtr[7] = sPtr[7];
  165.         dPtr[8] = sPtr[8];
  166.         dPtr[9] = sPtr[9];
  167.         dPtr[10] = sPtr[10];
  168.         dPtr[11] = sPtr[11];
  169.         dPtr[12] = sPtr[12];
  170.         dPtr[13] = sPtr[13];
  171.         dPtr[14] = sPtr[14];
  172.         dPtr[15] = sPtr[15];
  173.         sPtr += 16;
  174.         dPtr += 16;
  175.         numBytes -= 16*sizeof(int);
  176.         }
  177.         while (numBytes >= sizeof(int)) {
  178.         *dPtr++ = *sPtr++;
  179.         numBytes -= sizeof(int);
  180.         }
  181.         if (numBytes == 0) {
  182.         return;
  183.         }
  184.     }
  185.  
  186.     /*
  187.      * Copy the remaining bytes.
  188.      */
  189.  
  190.     sourcePtr = (char *) sPtr;
  191.     destPtr = (char *) dPtr;
  192.     while (numBytes > 0) {
  193.         *destPtr++ = *sourcePtr++;
  194.         numBytes--;
  195.     }
  196.     } else {
  197.     /*
  198.      * Handle extra bytes at the top that are due to the transfer
  199.      * length rather than pointer misalignment.
  200.      */
  201.     while (numBytes & WORDMASK) {
  202.         numBytes --;
  203.         destPtr[numBytes] = sourcePtr[numBytes];
  204.     }
  205.     sPtr = (int *) (sourcePtr + numBytes);
  206.     dPtr = (int *) (destPtr + numBytes);
  207.  
  208.     if (!((((int) sPtr) | (int) dPtr) & WORDMASK)) {
  209.         while (numBytes >= 16*sizeof(int)) {
  210.         sPtr -= 16;
  211.         dPtr -= 16;
  212.         dPtr[15] = sPtr[15];
  213.         dPtr[14] = sPtr[14];
  214.         dPtr[13] = sPtr[13];
  215.         dPtr[12] = sPtr[12];
  216.         dPtr[11] = sPtr[11];
  217.         dPtr[10] = sPtr[10];
  218.         dPtr[9] = sPtr[9];
  219.         dPtr[8] = sPtr[8];
  220.         dPtr[7] = sPtr[7];
  221.         dPtr[6] = sPtr[6];
  222.         dPtr[5] = sPtr[5];
  223.         dPtr[4] = sPtr[4];
  224.         dPtr[3] = sPtr[3];
  225.         dPtr[2] = sPtr[2];
  226.         dPtr[1] = sPtr[1];
  227.         dPtr[0] = sPtr[0];
  228.         numBytes -= 16*sizeof(int);
  229.         }
  230.         while (numBytes >= sizeof(int)) {
  231.         *--dPtr = *--sPtr;
  232.         numBytes -= sizeof(int);
  233.         }
  234.         if (numBytes == 0) {
  235.         return;
  236.         }
  237.     }
  238.  
  239.     /*
  240.      * Copy the remaining bytes.
  241.      */
  242.  
  243.     destPtr = (char *) dPtr;
  244.     sourcePtr = (char *) sPtr;
  245.     while (numBytes > 0) {
  246.         *--destPtr = *--sourcePtr;
  247.         numBytes--;
  248.     }
  249.     }
  250. }
  251. @
  252.  
  253.  
  254. 1.8
  255. log
  256. @Fixed a couple lint errors.
  257. @
  258. text
  259. @d17 1
  260. a17 1
  261. static char rcsid[] = "$Header: /sprite/src/lib/c/bstring/RCS/bcopy.c,v 1.7 91/03/24 19:03:11 kupfer Exp Locker: rab $ SPRITE (Berkeley)";
  262. d20 3
  263. a30 3
  264. #include "machparam.h"
  265. #include <bstring.h>
  266.  
  267. a41 4
  268. #ifdef KERNEL
  269. #include <vmHack.h>
  270. #endif
  271.  
  272. d61 3
  273. a63 3
  274. bcopy(sourcePtr, destPtr, numBytes)
  275.     char *sourcePtr;        /* Where to copy from */
  276.     char *destPtr;        /* Where to copy to */
  277. d66 4
  278. a69 2
  279.     register int *sPtr = (int *) sourcePtr;
  280.     register int *dPtr = (int *) destPtr;
  281. @
  282.  
  283.  
  284. 1.7
  285. log
  286. @Small hack so that the kernel can check for incorrect references to
  287. user addresses.
  288. @
  289. text
  290. @d17 1
  291. a17 1
  292. static char rcsid[] = "$Header: /sprite/src/lib/c/bstring/RCS/bcopy.c,v 1.6 90/09/11 14:13:21 kupfer Exp Locker: kupfer $ SPRITE (Berkeley)";
  293. a72 4
  294. #ifdef VM_CHECK_BSTRING_ACCESS
  295.     Vm_CheckAccessible(sourcePtr, numBytes);
  296.     Vm_CheckAccessible(destPtr, numBytes);
  297. #endif
  298. d87 1
  299. a87 1
  300.     
  301. d118 1
  302. a118 1
  303.     
  304. d122 1
  305. a122 1
  306.     
  307. d171 1
  308. a171 1
  309.     
  310. d175 1
  311. a175 1
  312.     
  313. @
  314.  
  315.  
  316. 1.7.1.1
  317. log
  318. @Initial branch for Sprite server.
  319. @
  320. text
  321. @d17 1
  322. a17 1
  323. static char rcsid[] = "$Header: /sprite/src/lib/c/bstring/RCS/bcopy.c,v 1.7 91/03/24 19:03:11 kupfer Exp Locker: rab $ SPRITE (Berkeley)";
  324. @
  325.  
  326.  
  327. 1.6
  328. log
  329. @Lint.
  330. @
  331. text
  332. @d17 1
  333. a17 1
  334. static char rcsid[] = "$Header: /sprite/src/lib/c/bstring/RCS/bcopy.c,v 1.5 90/09/07 14:20:30 jhh Exp Locker: kupfer $ SPRITE (Berkeley)";
  335. d42 4
  336. d73 4
  337. @
  338.  
  339.  
  340. 1.5
  341. log
  342. @fixed mis-aligned bcopy on a sun3
  343. @
  344. text
  345. @d17 1
  346. a17 1
  347. static char rcsid[] = "$Header: /sprite/src/lib/c/bstring/RCS/bcopy.c,v 1.4 88/07/25 13:16:02 ouster Exp Locker: jhh $ SPRITE (Berkeley)";
  348. d60 1
  349. @
  350.  
  351.  
  352. 1.4
  353. log
  354. @Lint.
  355. @
  356. text
  357. @d17 1
  358. a17 1
  359. static char rcsid[] = "$Header: bcopy.c,v 1.3 88/07/19 13:26:46 mendel Exp $ SPRITE (Berkeley)";
  360. d29 1
  361. d31 8
  362. d40 1
  363. @
  364.  
  365.  
  366. 1.3
  367. log
  368. @Import WORD_ALIGN_MASK from machparam.h.
  369. @
  370. text
  371. @d17 1
  372. a17 1
  373. static char rcsid[] = "$Header: bcopy.c,v 1.2 88/04/25 21:32:57 ouster Exp $ SPRITE (Berkeley)";
  374. a56 1
  375.     int tmp;
  376. @
  377.  
  378.  
  379. 1.2
  380. log
  381. @Bug fixes.
  382. @
  383. text
  384. @d17 1
  385. a17 1
  386. static char rcsid[] = "$Header: bcopy.c,v 1.1 88/04/25 17:21:58 ouster Exp $ SPRITE (Berkeley)";
  387. d24 2
  388. a25 2
  389.  * address, then word-based transfers may be used.  Eventually this
  390.  * mask needs to be handled in a more machine-independent fashion.
  391. d28 4
  392. a31 1
  393. #define WORDMASK 0x1
  394. @
  395.  
  396.  
  397. 1.1
  398. log
  399. @Initial revision
  400. @
  401. text
  402. @d17 1
  403. a17 1
  404. static char rcsid[] = "$Header: bcopy.c,v 1.1 88/04/25 13:25:41 ouster Exp $ SPRITE (Berkeley)";
  405. d52 2
  406. a53 2
  407.     register int *sPtr;
  408.     register int *dPtr;
  409. d62 1
  410. a62 1
  411.     if (destPtr < sourcePtr) {
  412. d64 1
  413. a64 1
  414.      * If both the sourcePtr and the destPtr point to aligned
  415. a70 3
  416.     sPtr = (int *)sourcePtr;
  417.     dPtr = (int *)destPtr;
  418.  
  419. a99 2
  420.         sourcePtr = (char *) sPtr;
  421.         destPtr = (char *) dPtr;
  422. d106 2
  423. d113 10
  424. a122 2
  425.     destPtr += numBytes;
  426.     sourcePtr += numBytes;
  427. d124 1
  428. a124 3
  429.     if (!((int) sPtr & WORDMASK) && !((int) dPtr & WORDMASK)) {
  430.         sPtr = (int *) sourcePtr;
  431.         dPtr = (int *) destPtr;
  432. a152 2
  433.         sourcePtr = (char *) sPtr;
  434.         destPtr = (char *) dPtr;
  435. d159 2
  436. @
  437.